﻿
select * from creditos.V_LISTAR_CUOTAS  where id_credito='13'and id_sucursal_credito=1

CREATE OR REPLACE FUNCTION creditos.getFuncCalMora(_id_cuota varchar(7),_ID_CREDITO varchar(8),_id_sucursar integer)
  RETURNS text AS
$BODY$
declare
	data record;
	mora double precision ;
	saldo numeric(20,6) ;
begin
select generaIntereses(CC.IMP_CUOTA,convertirTemToTead(5), CAST( now() AS DATE)-CAST(FEC_VENCIMIENTO AS DATE) ) into mora from creditos.v_listar_imp_cal_mora cc
where trunc(cc.SALDO,2)>0 and FEC_VENCIMIENTO<now() and cc.nro_cuota<>0 
	and CC.ID_CUOTA=_ID_CUOTA 
	AND CC.ID_CREDITO=_ID_CREDITO 
	AND CC.id_sucursal_credito=_id_sucursar;
	if mora is not Null then
		select   (CC.IMP_CUOTA+CC.IMP_MORA-COALESCE((SELECT sum(M.IMP_MOVIMIENTO) FROM CAJA.TB_MOVIMIENTO M 
		WHERE CC.ID_CUOTA=M.ID_CUOTA 
		AND CC.ID_CREDITO=M.ID_CREDITO 
		AND CC.id_sucursal_credito=M.id_sucursal_credito ) ,0)) into saldo  from creditos.tb_cuota cc;
		if trunc(saldo,2)>0 then
			update creditos.tb_cuota set IMP_MORA=mora where  ID_CUOTA=_ID_CUOTA AND ID_CREDITO=_ID_CREDITO AND id_sucursal_credito=_id_sucursar;
		end if;
		return mora;	
	else
		return 0;
	end if;
--return mora;	
end;$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;

select *from creditos.tb_cuota


create or replace function generaIntereses(P  numeric,i NUMERIC, n INTEGER)
returns numeric as $$
declare
	IT NUMERIC;
	tasaAntesElevar NUMERIC;
	tasaDespuesElevar NUMERIC;
begin
	 tasaAntesElevar = (1+(i/100));
        tasaDespuesElevar = power(tasaAntesElevar,n);
        IT=P*(tasaDespuesElevar-1);
        return IT;
end;$$
language 'plpgsql';



create or replace function convertirTeaToTeam( tasa numeric)
returns numeric as $$
declare
	 temSalida numeric;
	 tasaAntesElevar numeric;
	 tasaDespuesElevar numeric;
	 indice numeric;
	 NUM numeric;
	 DEN numeric;
begin
	NUM=1;
        DEN=12;        
        tasaAntesElevar = (1+(tasa/100));
        indice=NUM/DEN;
        tasaDespuesElevar = power(tasaAntesElevar,indice);
        temSalida=(tasaDespuesElevar-1)*100; --// Volviendo la tasa a %
        return temSalida; 
	
end;$$
language 'plpgsql';




create or replace function convertirTemToTead( tasa numeric)
returns numeric as $$
declare
	 temSalida numeric;
	 tasaAntesElevar numeric;
	 tasaDespuesElevar numeric;
	 indice numeric;
	 NUM numeric;
	 DEN numeric;
begin
	NUM=1;
        DEN=30;        
        tasaAntesElevar = (1+(tasa/100));
        indice=NUM/DEN;
        tasaDespuesElevar = power(tasaAntesElevar,indice);
        temSalida=(tasaDespuesElevar-1)*100; --// Volviendo la tasa a %
        return temSalida; 
	
end;$$
language 'plpgsql';



create or replace function convertirTemToTea( tasa numeric)
returns numeric as $$
declare
	 teaSalida numeric;
	 tasaAntesElevar numeric;
	 tasaDespuesElevar numeric;
	 indice numeric;
	 NUM numeric;
	 DEN numeric;
begin

        tasaAntesElevar = (1+(tasa/100));
        DEN=12;
        indice=DEN;
        tasaDespuesElevar = power(tasaAntesElevar,indice);
        teaSalida=(tasaDespuesElevar-1)*100; --  // Volviendo la tasa a %
        return teaSalida;
	
end;$$
language 'plpgsql';


CREATE OR REPLACE FUNCTION fu_numero_letras(numero numeric)
  RETURNS text AS
$BODY$
DECLARE
     lnEntero INTEGER;
     lcRetorno TEXT;
     lnTerna INTEGER;
     lcMiles TEXT;
     lcCadena TEXT;
     lnUnidades INTEGER;
     lnDecenas INTEGER;
     lnCentenas INTEGER;
     lnFraccion INTEGER;
     lnSw INTEGER;
BEGIN
     lnEntero := FLOOR(numero)::INTEGER;--Obtenemos la parte Entera
     lnFraccion := FLOOR(((numero - lnEntero) * 100))::INTEGER;--Obtenemos la Fraccion del Monto
     lcRetorno := '';
     lnTerna := 1;
     IF lnEntero > 0 THEN
     lnSw := LENGTH(lnEntero::TEXT);
     WHILE lnTerna <= lnSw LOOP
        -- Recorro terna por terna
        lcCadena = '';
        lnUnidades = lnEntero % 10;
        lnEntero = CAST(lnEntero/10 AS INTEGER);
        lnDecenas = lnEntero % 10;
        lnEntero = CAST(lnEntero/10 AS INTEGER);
        lnCentenas = lnEntero % 10;
        lnEntero = CAST(lnEntero/10 AS INTEGER);
    -- Analizo las unidades
       SELECT
         CASE /* UNIDADES */
           WHEN lnUnidades = 1 AND lnTerna = 1 THEN 'UNO ' || lcCadena
           WHEN lnUnidades = 1 AND lnTerna <> 1 THEN 'UN ' || lcCadena
           WHEN lnUnidades = 2 THEN 'DOS ' || lcCadena
           WHEN lnUnidades = 3 THEN 'TRES ' || lcCadena
           WHEN lnUnidades = 4 THEN 'CUATRO ' || lcCadena
           WHEN lnUnidades = 5 THEN 'CINCO ' || lcCadena
           WHEN lnUnidades = 6 THEN 'SEIS ' || lcCadena
           WHEN lnUnidades = 7 THEN 'SIETE ' || lcCadena
           WHEN lnUnidades = 8 THEN 'OCHO ' || lcCadena
           WHEN lnUnidades = 9 THEN 'NUEVE ' || lcCadena
           ELSE lcCadena
          END INTO lcCadena;
          /* UNIDADES */
    -- Analizo las decenas
    SELECT
    CASE /* DECENAS */
      WHEN lnDecenas = 1 THEN
        CASE lnUnidades
          WHEN 0 THEN 'DIEZ '
          WHEN 1 THEN 'ONCE '
          WHEN 2 THEN 'DOCE '
          WHEN 3 THEN 'TRECE '
          WHEN 4 THEN 'CATORCE '
          WHEN 5 THEN 'QUINCE '
          ELSE 'DIECI' || lcCadena
        END
      WHEN lnDecenas = 2 AND lnUnidades = 0 THEN 'VEINTE ' || lcCadena
      WHEN lnDecenas = 2 AND lnUnidades <> 0 THEN 'VEINTI' || lcCadena
      WHEN lnDecenas = 3 AND lnUnidades = 0 THEN 'TREINTA ' || lcCadena
      WHEN lnDecenas = 3 AND lnUnidades <> 0 THEN 'TREINTA Y ' || lcCadena
      WHEN lnDecenas = 4 AND lnUnidades = 0 THEN 'CUARENTA ' || lcCadena
      WHEN lnDecenas = 4 AND lnUnidades <> 0 THEN 'CUARENTA Y ' || lcCadena
      WHEN lnDecenas = 5 AND lnUnidades = 0 THEN 'CINCUENTA ' || lcCadena
      WHEN lnDecenas = 5 AND lnUnidades <> 0 THEN 'CINCUENTA Y ' || lcCadena
      WHEN lnDecenas = 6 AND lnUnidades = 0 THEN 'SESENTA ' || lcCadena
      WHEN lnDecenas = 6 AND lnUnidades <> 0 THEN 'SESENTA Y ' || lcCadena
      WHEN lnDecenas = 7 AND lnUnidades = 0 THEN 'SETENTA ' || lcCadena
      WHEN lnDecenas = 7 AND lnUnidades <> 0 THEN 'SETENTA Y ' || lcCadena
      WHEN lnDecenas = 8 AND lnUnidades = 0 THEN 'OCHENTA ' || lcCadena
      WHEN lnDecenas = 8 AND lnUnidades <> 0 THEN 'OCHENTA Y ' || lcCadena
      WHEN lnDecenas = 9 AND lnUnidades = 0 THEN 'NOVENTA ' || lcCadena
      WHEN lnDecenas = 9 AND lnUnidades <> 0 THEN 'NOVENTA Y ' || lcCadena
      ELSE lcCadena
    END INTO lcCadena; /* DECENAS */
    -- Analizo las centenas
    SELECT
    CASE /* CENTENAS */
      WHEN lnCentenas = 1 AND lnUnidades = 0 AND lnDecenas = 0 THEN 'CIEN ' || lcCadena
      WHEN lnCentenas = 1 AND NOT(lnUnidades = 0 AND lnDecenas = 0) THEN 'CIENTO ' || lcCadena
      WHEN lnCentenas = 2 THEN 'DOSCIENTOS ' || lcCadena
      WHEN lnCentenas = 3 THEN 'TRESCIENTOS ' || lcCadena
      WHEN lnCentenas = 4 THEN 'CUATROCIENTOS ' || lcCadena
      WHEN lnCentenas = 5 THEN 'QUINIENTOS ' || lcCadena
      WHEN lnCentenas = 6 THEN 'SEISCIENTOS ' || lcCadena
      WHEN lnCentenas = 7 THEN 'SETECIENTOS ' || lcCadena
      WHEN lnCentenas = 8 THEN 'OCHOCIENTOS ' || lcCadena
      WHEN lnCentenas = 9 THEN 'NOVECIENTOS ' || lcCadena
      ELSE lcCadena
    END INTO lcCadena;/* CENTENAS */
    -- Analizo la terna
    SELECT
    CASE /* TERNA */
      WHEN lnTerna = 1 THEN lcCadena
      WHEN lnTerna = 2 AND (lnUnidades + lnDecenas + lnCentenas <> 0) THEN lcCadena || ' MIL '
      WHEN lnTerna = 3 AND (lnUnidades + lnDecenas + lnCentenas <> 0) AND
        lnUnidades = 1 AND lnDecenas = 0 AND lnCentenas = 0 THEN lcCadena || ' MILLON '
      WHEN lnTerna = 3 AND (lnUnidades + lnDecenas + lnCentenas <> 0) AND
        NOT (lnUnidades = 1 AND lnDecenas = 0 AND lnCentenas = 0) THEN lcCadena || ' MILLONES '
      WHEN lnTerna = 4 AND (lnUnidades + lnDecenas + lnCentenas <> 0) THEN lcCadena || ' MIL MILLONES '
      ELSE ''
    END INTO lcCadena;/* TERNA */
 
    --Retornamos los Valores Obtenidos
    lcRetorno = lcCadena  || lcRetorno;
    lnTerna = lnTerna + 1;
    END LOOP;
  END IF;
  IF lnTerna = 1 THEN
    lcRetorno := 'CERO';
  END IF;
  lcRetorno := RTRIM(lcRetorno::TEXT) || ' Y ' || LTRIM(TO_CHAR(lnFraccion,'00')) || '/100 NUEVOS SOLES';
RETURN lcRetorno;
END;
$BODY$
  LANGUAGE plpgsql VOLATILE;

create or replace function isp_grabar_unidad(
	  _id_unidad integer  ,
	  _des_unidad character varying(20)  
	)returns text as  $$
	
declare
 RES TEXT;
begin
	insert into tb_unidad (id_unidad,des_unidad)values(_id_unidad,_des_unidad);
	if not found then
		res:='-1';
	end if;
	res:='0';
	return res;
end;$$
language plpgsql;	
	  
create or replace function HOTEL.isp_grabar_habitacion(
	  _op integer,
	  _id_habitacion integer  ,
	  _num_habitacion character varying(20)  ,
	  _id_tipohabitacion integer ,
	  _capacidad integer,
	  _piso_habitacion integer,
	  _fecha DATE,
	  _genera_almacen character(1),
	  _id_estado integer,
	  _id_pisohotel integer
	
)
returns text as $$
declare
	RES TEXT;
begin
if _op =1 then
	if not exists (select *from HOTEL.TB_HABITACION where id_pisohotel=_id_pisohotel and trim(num_habitacion)=trim(_num_habitacion)) then
		INSERT INTO HOTEL.TB_HABITACION (
			id_habitacion, 
			num_habitacion, 
			id_tipohabitacion, 
			capacidad, 
			piso_habitacion, 
			fecha, 
			genera_almacen, 
			id_estado, 
			id_pisohotel
		)VALUES(
			_id_habitacion, 
			_num_habitacion, 
			_id_tipohabitacion, 
			_capacidad, 
			_piso_habitacion, 
			_fecha, 
			_genera_almacen, 
			_id_estado, 
			_id_pisohotel
		)RETURNING  '0' || HOTEL.TB_HABITACION.id_habitacion INTO RES;
		--RES:='0';
	     IF NOT FOUND THEN
		RES:='-1';
	     END IF;
	ELSE
		RES:='-10';
	end if;
end if;
if _op=3 then
	if exists (select *from hotel.tb_habitacion where id_habitacion=_id_habitacion) then
		update hotel.tb_habitacion set 
			num_habitacion=_num_habitacion, 
			id_tipohabitacion=_id_tipohabitacion, 
			capacidad=_capacidad, 
			piso_habitacion=_piso_habitacion, 
			genera_almacen=_genera_almacen, 
			id_estado=_id_estado, 
			id_pisohotel=_id_pisohotel where id_habitacion=_id_habitacion;
			RES:='0';
	   IF NOT FOUND THEN
		RES:='-2';
	     END IF;
	ELSE
		RES:='-30';
	end if;
end if;
	RETURN RES;
end;$$
language 'plpgsql';


--GRABANDO LA LSITA DE PRECIOS DE LAS HABITACIONES DEL HOTEL

CREATE OR REPLACE FUNCTION HOTEL.ISP_GRBA_TARIFA_HOTEL
( 
	  _op integer, 	
	  _id_tarifa integer  ,
	  _des_tarifa character varying(20),
	  _id_estado integer,
	  _id_habitacion integer  ,
	  _id_lista_hotel integer  ,
	  _id_moneda integer  ,
	  _precio1 numeric(14,6),
	  _precio2 numeric(14,6),
	  _precio3 numeric(14,6),
	  _precio4 numeric(14,6),
	  _precio5 numeric(14,6)
)RETURNS TEXT AS  $$

DECLARE
res text;
BEGIN
if _op =1 then
	IF EXISTS (SELECT *FROM HOTEL.tb_habitacion WHERE id_habitacion=_id_habitacion) THEN
		insert into hotel.tb_tarifa_hotel(
			id_tarifa, 
			des_tarifa, 	
			id_estado, 
			id_habitacion, 
			id_lista_hotel, 
			id_moneda, 
			precio1, 
			precio2, 
			precio3, 
			precio4, 
			precio5
		)values(
			_id_tarifa, 
			_des_tarifa, 	
			_id_estado, 
			_id_habitacion, 
			_id_lista_hotel, 
			_id_moneda, 
			_precio1, 
			_precio2, 
			_precio3, 
			_precio4, 
			_precio5
		) ;
		res:='0';
		if not found then
			res:='-11';
		end if;
	else
		res:='-20';
	END IF;
end if;

if _op=3 then
	if exists (select *from hotel.tb_tarifa_hotel where id_tarifa=_id_tarifa and  id_habitacion=_id_habitacion and id_lista_hotel=_id_lista_hotel) then
		update hotel.tb_tarifa_hotel set 
			des_tarifa=_des_tarifa, 	
			id_estado=_id_estado, 
			id_moneda=_id_moneda, 
			precio1=_precio1, 
			precio2=_precio2, 
			precio3=_precio3, 
			precio4=_precio4, 
			precio5=_precio5
		where id_tarifa=_id_tarifa and  id_habitacion=_id_habitacion and id_lista_hotel=_id_lista_hotel;
		res:='0';
		if not found then
			res:='-12';
		end if;
	else
		res:='-22';
	end if;
end if;
	return res;
END;$$
LANGUAGE 'plpgsql';


--ALTER TABLE ALMACEN.TB_GRUPO ADD COLUMN ID_ESTADO INTEGER;

--select *from almacen.isp_grabar_grupos(3,'1','pan',1);
create or replace function almacen.isp_grabar_grupos(
	_op integer,
	_idgrupo CHAR(3),
	_nombre varchar(100),
	_id_estado integer
)
returns text as  $$
declare
	res text;
begin
if _op=1 then
	if not exists(select 1 from almacen.tb_grupo where nombre=_nombre) then
		insert into almacen.tb_grupo (
			idgrupo,
			nombre,
			id_estado
		) 
		values(
			_idgrupo,
			_nombre,
			_id_estado
		) returning '0' || almacen.tb_grupo.idgrupo into res;
		--res:='0';
		if not found then
			res:='-1';
		end if;
	else
		res:='-2';
	end if;
end if;
if _op=3 then
	if exists(select 1 from almacen.tb_grupo where idgrupo=_idgrupo) then
		update almacen.tb_grupo 
		set 
		nombre=_nombre,id_estado=_id_estado 
		where idgrupo=_idgrupo;
		res:='0';
		if not found then
			res:='-3';
		end if;
	else
		res:='-4';
	end if;
end if;
return res;
end;$$
language 'plpgsql';

--ALTER TABLE ALMACEN.TB_FAMILIA ADD COLUMN IDESTADO INTEGER;

/*
ALTER TABLE ALMACEN.TB_FAMILIA
	ADD FOREIGN KEY (IDGRUPO) REFERENCES ALMACEN.TB_GRUPO (IDGRUPO);

*/
create or replace function almacen.isp_grabar_familas(
  _op integer,
  _idfamilia character(3),
  _nombre character varying(100),
  _idgrupo character(3) ,
  _idusuario character(4),
  _modifica character(1),
  _idestado integer
)
returns text as $$
declare
	res text;
begin
if _op =1 then
	if not exists(select *from almacen.tb_familia where nombre=_nombre ) then
	    insert into almacen.tb_familia (
		  --idfamilia,
                  nombre,
		  idgrupo,
		  idusuario_r,
		  idestado
	    )
	    values(
		  --_idfamilia,
                  _nombre,
		 trim(_idgrupo),
		  _idusuario,
		  _idestado
	    )returning '0' || almacen.tb_familia.idfamilia into res ;
	    --res:='0';
	    if not found then
		res:='-1';
	    end if;
	else
		res:='-2';
	end if;
end if;

if _op=3 then
	if exists(select *from almacen.tb_familia where idfamilia=_idfamilia)then
		update almacen.tb_familia set 
		  nombre=_nombre,
		  idgrupo=_idgrupo,
		  idusuario_a=_idusuario,
		  idestado=_idestado where idfamilia=_idfamilia;
		  res:='0';
		  if not found then
			res:='-3';
		  end if;
	else
		res:='-4';
	end if;

end if;	
return res;
end;$$
language 'plpgsql';

--ALTER TABLE COMMON.TB_UNIDAD ADD COLUMN VENTA_CON_FRACCION BOOLEAN DEFAULT TRUE;
--ALTER TABLE COMMON.TB_UNIDAD ADD COLUMN VAL_VENTA NUMERIC(14,6);
--ALTER TABLE COMMON.TB_UNIDAD ADD COLUMN VAL_MINIMO NUMERIC(14,6);

CREATE OR REPLACE FUNCTION COMMON.ISP_GRABAR_UNIDAD(
  _op integer,
  _id_unidad integer ,
  _des_unidad character varying(100),
  _abreviatura character(4),
  _venta_con_fraccion boolean,
  _val_venta numeric(14,6),
  _val_minimo numeric(14,6),
  _id_estado integer,
  _idusuario character(4)

)
RETURNS TEXT AS $$
DECLARE
	res text;
BEGIN
 if _op=1 then
	if not exists(select *from common.tb_unidad where des_unidad=_des_unidad) then
		insert into common.tb_unidad(
			  id_unidad,
			  des_unidad,
			  abreviatura,
			  venta_con_fraccion,
			  val_venta,
			  val_minimo,
			  id_estado,
			  idusuario_r,
			  idusuario_a,
			  fec_registro,
			  date_act
		)
		values(
			_id_unidad,
			_des_unidad,
			_abreviatura,
			_venta_con_fraccion,
			_val_venta,
			_val_minimo,
			_id_estado,
			_idusuario,
			_idusuario,
			now(),
			now()									

		)returning '0' || common.tb_unidad.id_unidad into res;
		if not found then
			res:='-1';
		end if;
	else
		res:='-2';
	end if;

 end if;
 if _op=3 then
	if exists(select *from common.tb_unidad where id_unidad=_id_unidad) then
		update common.tb_unidad set 			  
			  des_unidad=_des_unidad,
			  abreviatura=_abreviatura,
			  venta_con_fraccion=_venta_con_fraccion,
			  val_venta=_val_venta,
			  val_minimo=_val_minimo,
			  id_estado=_id_estado,
			  idusuario_a=_idusuario,
			  date_act=NOW() WHERE id_unidad=_id_unidad;
		RES:='0';	  
		IF not found then
			res:='-3';
		end if;
	else
		res:='-4';	
	end if;

 end if;
return res;
END;$$
LANGUAGE "plpgsql";


--alter table almacen.tb_producto add column id_estado integer;

CREATE OR REPLACE FUNCTION ALMACEN.ISP_GRABAR_PRODUCTO(
	  _op integer,
	  _id_producto character varying(19)  ,
	  _minicodigo character(5),
	  _descripcion character varying(100),
	  _descripcion_larga text,
	  _cod_bar character varying(24),
	  _inc_serie character(1),
	  _prod_serv character(1),
	  _inc_barra character(1),
	  _impuesto numeric(14,6),
	  _reintegro_tributario character(1),
	  _partida_arancelaria character varying(24),
	  _ubica_almacen text,
	  _pide_objetivos character(1),
	  _obs_compra text,
	  _obs_ventas text,
	  _controla_stock character(1),
	  _prececible character(1),
	  _suje_peresepcion character(1),
	  _vende_pack character(1),
	  _idfamilia character(3),
	  _id_estado integer
)
RETURNS TEXT[] AS  $$
DECLARE
	res text[];
BEGIN
if _op=1 then
	if not exists(select * from almacen.tb_producto where descripcion_larga=_descripcion_larga) then
		INSERT INTO almacen.tb_producto(
			    id_producto, 
			    minicodigo, 
			    descripcion, 
			    descripcion_larga, 
			    cod_bar, 
			    inc_serie, 
			    prod_serv, 
			    inc_barra, 
			    impuesto, 
			    reintegro_tributario, 
			    partida_arancelaria, 
			    ubica_almacen, 
			    pide_objetivos, 
			    obs_compra, 
			    obs_ventas, 
			    controla_stock, 
			    perecible, 
			    suje_peresepcion, 
			    vende_pack, 
			    idfamilia,
			    id_estado
			    )
		VALUES (
			_id_producto, 
			_minicodigo, 
			_descripcion, 
			_descripcion_larga, 
			_cod_bar, 
			_inc_serie, 
			_prod_serv, 
			_inc_barra, 
			_impuesto, 
			_reintegro_tributario, 
			_partida_arancelaria, 
			_ubica_almacen, 
			_pide_objetivos, 
			_obs_compra, 
			_obs_ventas, 
			_controla_stock, 
			_prececible, 
			_suje_peresepcion, 
			_vende_pack, 
			_idfamilia,
			_id_estado
		) returning ARRAY['0', tb_producto.id_producto] into res;
		if not found then
			res:=ARRAY['-1'];
		end if;
	else
		res:=ARRAY['-2'];
	end if;
end if;
if _op=3 then
	if exists (select *from almacen.tb_producto where id_producto=_id_producto)then
		UPDATE almacen.tb_producto
		   SET minicodigo=_minicodigo, 
			descripcion=_descripcion, 
			descripcion_larga=_descripcion_larga, 
		       cod_bar=_cod_bar, 
		       inc_serie=_inc_serie, 
		       prod_serv=prod_serv, 
		       inc_barra=inc_barra, 
		       impuesto=_impuesto, 
		       reintegro_tributario=_reintegro_tributario, 
		       partida_arancelaria=_partida_arancelaria, 
		       ubica_almacen=_ubica_almacen, 
		       pide_objetivos=_pide_objetivos, 
		       obs_compra=_obs_compra, 
		       obs_ventas=_obs_ventas, 
		       controla_stock=_controla_stock, 
		       perecible=_prececible, 
		       suje_peresepcion=_suje_peresepcion, 
		       vende_pack=_vende_pack, 
		       idfamilia=_idfamilia,
		       id_estado=_id_estado
		WHERE  id_producto=_id_producto;
			res:=ARRAY['0'];
		IF not found then
			res:=ARRAY['-3'];
		end if;
	else
		res:=ARRAY['-4'];	
	end if;
end if;
return res;
END;$$
LANGUAGE plpgsql;


select *from almacen.tb_saldo


CREATE OR REPLACE  FUNCTION ALMACEN.ISP_GRBAR_SALDO_ALM(
          _anio integer  ,
	  _mes integer  ,
	  _stockinicial numeric(14,6),
	  _stockactual numeric(14,6),
	  _saldo numeric(14,6),
	  _costo_promedio numeric(14,6),
	  _totalcosto numeric(14,6),
	  _stock_transito numeric(14,6),
	  _stock_comprometido numeric(14,6),
	  _id_almacen integer  ,
	  _id_precios integer  ,
	  _id_unidad integer  ,
	  _id_producto character varying(19)  ,
	  _id_lista integer ,
	  _costo_inicial numeric(14,6)

)
RETURNS TEXT AS $$
DECLARE 
	RES TEXT;
	regs record;
BEGIN
	if not exists (select *from almacen.tb_saldo where anio=_anio and 
						mes=_mes and 
						id_almacen=_id_almacen and  
						id_precios=_id_precios  and 
						id_unidad=_id_unidad and  
						id_producto=_id_producto and id_lista=_id_lista) then
		for regs in select *from almacen.tb_almacen loop
			INSERT INTO almacen.tb_saldo(
					    anio, 
					    mes, 
					    stockinicial, 
					    stockactual, 
					    saldo, 
					    costo_promedio, 
					    totalcosto, 
					    stock_transito, 
					    stock_comprometido, 
					    id_almacen, 
					    id_precios, 
					    id_unidad, 
					    id_producto, 
					    id_lista, 
					    costo_inicial
				    )
			    VALUES (
				    _anio, 
				    _mes, 
				    _stockinicial, 
				    _stockactual, 
				    _saldo, 
				    _costo_promedio, 
				    _totalcosto, 
				    _stock_transito, 
				    _stock_comprometido, 
				    regs.id_almacen, 
				    _id_precios, 
				    _id_unidad, 
				    _id_producto, 
				    _id_lista, 
				    _costo_inicial
			);
		end loop;
		RES:='0';
		if not found then
			res:='-1';
		end if;
	ELSE
		RES:='0';
	end if;
return RES;
END;$$
LANGUAGE 'plpgsql';

select  date_part('year',now())
select  date_part('month',now())

CREATE OR REPLACE FUNCTION ALMACEN.ISP_GRABAR_PRECIOS(
	  _op integer,
	  _id_producto character varying(19)  ,
	  _id_unidad integer ,
	  _id_lista integer  ,
	  _importe_costo numeric(14,6),
	  _imp_flete numeric(14,6),
	  _imp_emablaje numeric(14,6),
	  _imp_otros_costos numeric(14,6),
	  _peso numeric(14,6),
	  _costo_promedio numeric(14,6),
	  _cosnto_unitario numeric(14,6),
	  _costo_igv numeric(14,6),
	  _costo_almacen numeric(14,6),
	  _predeterminado boolean,
	  _porcent_util1 numeric(14,6),
	  _porcent_util2 numeric(14,6),
	  _porcent_util3 numeric(14,6),
	  _porcent_util4 numeric(14,6),
	  _porcent_util5 numeric(14,6),
	  _precio1 numeric(14,6),
	  _precio2 numeric(14,6),
	  _precio3 numeric(14,6),
	  _precio4 numeric(14,6),
	  _precio5 numeric(14,6),
	  _porcent_dsct numeric(14,6),
	  _val_unidad numeric(14,6),
	  _val_minimo numeric(14,6),
	  _id_moneda integer  ,
	  _id_precios integer  ,
	  _idusuario character(4),
	  _id_estado integer
)
RETURNS TEXT AS  $$
DECLARE
	RES TEXT;
BEGIN
IF _OP=1 THEN
	IF  EXISTS (SELECT 1 FROM ALMACEN.TB_PRODUCTO WHERE ID_PRODUCTO=_id_producto ) THEN
		IF EXISTS (SELECT  1 FROM COMMON.TB_UNIDAD WHERE ID_UNIDAD=_ID_UNIDAD) THEN
			IF EXISTS(SELECT 1 FROM ALMACEN.TB_LISTA_PRECIO WHERE ID_LISTA=_ID_LISTA) THEN
				INSERT INTO almacen.tb_precio(
				    id_producto, 
				    id_unidad, 
				    id_lista, 
				    importe_costo, 
				    imp_flete, 
				    imp_embalaje, 
				    imp_otros_costos, 
				    peso, 
				    costo_promedio, 
				    costo_unitario, 
				    costo_igv, 
				    costo_almacen, 
				    predeterminado, 
				    porcent_util1, 
				    porcent_util2, 
				    porcent_util3, 
				    porcent_util4, 
				    porcent_util5, 
				    precio1, 
				    precio2, 
				    precio3, 
				    precio4, 
				    precio5, 
				    porcent_dsct, 
				    date_act, 
				    val_unidad, 
				    val_minimo, 
				    id_moneda, 
				    id_precios, 
				    idusuario_a, 
				    idusuario_r, 
				    fec_registro,
				    id_estado
				    )
			    VALUES (
				   _id_producto, 
				    _id_unidad, 
				    _id_lista, 
				    _importe_costo, 
				    _imp_flete, 
				    _imp_emablaje, 
				    _imp_otros_costos, 
				    _peso, 
				    _costo_promedio, 
				    _cosnto_unitario, 
				    _costo_igv, 
				    _costo_almacen, 
				    _predeterminado, 
				    _porcent_util1, 
				    _porcent_util2, 
				    _porcent_util3, 
				    _porcent_util4, 
				    _porcent_util5, 
				    _precio1, 
				    _precio2, 
				    _precio3, 
				    _precio4, 
				    _precio5, 
				    _porcent_dsct, 
				    NOW(), 
				    _val_unidad, 
				    _val_minimo, 
				    _id_moneda, 
				    _id_precios, 
				    _idusuario, 
				    _idusuario, 
				    NOW(),
				    _id_estado
			    );

				  
			    RES:=ALMACEN.ISP_GRBAR_SALDO_ALM(
				    date_part('year',now())::integer, 
				    date_part('month',now())::integer, 
				    0.00, 
				    0.00, 
				    0.00, 
				    0.00, 
				    0.00, 
				    0.00, 
				    0.00, 
				    1, 
				    _id_precios, 
				    _id_unidad, 
				    _id_producto, 
				    _id_lista, 
				    0
				    );
				RES:='0';
			    IF NOT FOUND THEN
				RES:='-11';
			    END IF;
			ELSE
				RES:='-12';
			END IF;
		ELSE
			RES:='-13';
		END IF;
	ELSE
		RES:='-14';
	END IF;
END IF;
IF _OP=3 THEN
    IF EXISTS (SELECT 1 FROM ALMACEN.TB_PRECIO WHERE ID_LISTA=_ID_LISTA AND ID_PRODUCTO=_ID_PRODUCTO AND ID_UNIDAD=_ID_UNIDAD AND ID_PRECIOS=_ID_PRECIOS) THEN
		UPDATE almacen.tb_precio
		   SET 
		   importe_costo=_importe_costo, 
		   imp_flete=_imp_flete, 
		   imp_embalaje=_imp_emablaje, 
		   imp_otros_costos=_imp_otros_costos, 
		   peso=_peso, 
		   costo_promedio=_costo_promedio, 
		   costo_unitario=_cosnto_unitario, 
		   costo_igv=_costo_igv, 
		   costo_almacen=_costo_almacen, 
		   predeterminado=_predeterminado, 
		   porcent_util1=_porcent_util1, 
		   porcent_util2=_porcent_util2, 
		   porcent_util3=_porcent_util3, 
		   porcent_util4=_porcent_util4, 
		   porcent_util5=_porcent_util5, 
		   precio1=_precio1, 
		   precio2=_precio2, 
		   precio3=_precio3, 
		   precio4=_precio4, 
		   precio5=_precio5, 
		   porcent_dsct=_porcent_dsct, 
		   date_act=NOW(), 
		   val_unidad=_val_unidad, 
		   val_minimo=_val_minimo, 
		   id_moneda=_id_moneda, 
		   idusuario_a=_idusuario,
		   id_estado=_id_estado
		 WHERE ID_LISTA=_ID_LISTA AND ID_PRODUCTO=_ID_PRODUCTO AND ID_UNIDAD=_ID_UNIDAD AND ID_PRECIOS=_ID_PRECIOS;
		 RES:=ALMACEN.ISP_GRBAR_SALDO_ALM(
				     date_part('year',now())::integer, 
				    date_part('month',now())::integer, 
				    0.00, 
				    0.00, 
				    0.00, 
				    0.00, 
				    0.00, 
				    0.00, 
				    0.00, 
				    1, 
				    _id_precios, 
				    _id_unidad, 
				    _id_producto, 
				    _id_lista, 
				    0
				    );
				--RES:='0';
		 RES:='0';
		 IF NOT FOUND THEN
			RES:='-15';
		 END IF;
	ELSE
		RES:='-16';
	END IF;	
END IF;
RETURN RES;
END;$$
LANGUAGE 'plpgsql';


alter table almacen.tb_almacen add column direccion text;
alter table almacen.tb_almacen add column ubigeo varchar(10);

select *from COMMON.TB_UBIGEO  where ubigeo<>''

ALTER TABLE ALMACEN.TB_ALMACEN
	ADD FOREIGN KEY (UBIGEO) REFERENCES COMMON.TB_UBIGEO (UBIGEO);
	
create or replace function almacen.isp_grabar_almacen(
	  _op integer,
	  _id_almacen integer ,
	  _des_almacen character varying(20),
	  _ubigeo varchar(10),
	  _direccion text,
	  _id_estado integer,
	  _id_responsable varchar(12),
	  _id_hotel integer  ,
	  _idusuario character(4),
	  _is_principal integer
)
returns text as $$
declare
	res text;
begin
res:='-9';
if _op=1 then
	if exists (select *from hotel.tb_hotel where id_hotel=_id_hotel ) then
		if not exists (select *from almacen.tb_almacen where des_almacen=_des_almacen) then
			INSERT INTO almacen.tb_almacen(
			    id_almacen, 
			    des_almacen, 
			    ubigeo,
			    direccion,
			    id_estado, 
			    id_responsable, 
			    id_hotel, 
			    idusuario_a, 
			    idusuario_r, 
			    fec_registro, 
			    date_act,
			    is_principal
			    )
		    VALUES (_id_almacen, 
			    _des_almacen, 
			    _ubigeo,
			    _direccion,
			    _id_estado, 
			    _id_responsable, 
			    _id_hotel, 
			    _idusuario, 
			    _idusuario, 
			    now(), 
			    now(),
			    _is_principal
			    );
			    res:='0';
			    if not found then 
				res:='-1';
			    end if;
		else
			res:='-2';
		end if;
	else
		res:='-3';
	end if;
end if;
if _op=3 then 
	if  exists(select *from almacen.tb_almacen where id_almacen=_id_almacen) then
		UPDATE almacen.tb_almacen
		   SET  des_almacen=_des_almacen, 
		   ubigeo=_ubigeo,
		   direccion=_direccion,
		   id_estado=_id_estado, 
		   id_responsable=_id_responsable, 
		   id_hotel=_id_hotel, 
		   idusuario_a=_idusuario,
		   date_act=now(),
		   is_principal=_is_principal
		 WHERE id_almacen=_id_almacen;
		res:='0';
		 if not found then
			res:='4';
		 end if;
	else
		res:='5';
	end if;
end if;
return res;
end;$$
language plpgsql;

ALTER TABLE caja.tb_caja_banco DROP COLUMN estado;
ALTER TABLE caja.tb_caja_banco ADD COLUMN id_estado integer;
ALTER TABLE caja.tb_caja_banco ADD COLUMN id_sucursal integer;

ALTER TABLE CAJA.TB_CAJA_BANCO
	ADD FOREIGN KEY (id_sucursal) REFERENCES HOTEL.TB_HOTEL (ID_HOTEL);

CREATE OR REPLACE FUNCTION CAJA.ISP_GRABAR_CAJA(
  _op integer,
  _id_caja integer  ,
  _nombre character varying(100),
  _id_estado integer,
  _venta_credito character(1),
  _venta_contado character(1),
  _pago_proveed character(1),
  _cobranzas character(1),
  _id_tipcaja integer ,
  _id_moneda integer  ,
  _caja_banco character(1),
  _nro_cuenta character varying(25),
  _idusuario character(4),
  _id_sucursal integer
)
RETURNS TEXT AS  $$
DECLARE 
  res text;
begin
  if _op=1 then
	if not exists(select *from caja.tb_caja_banco where nombre=_nombre) then
		IF EXISTS (SELECT *FROM HOTEL.TB_HOTEL WHERE id_hotel=_id_sucursal) then
			INSERT INTO caja.tb_caja_banco(
				    id_caja, 
				    nombre, 
				    id_estado, 
				    fec_registro, 
				    date_act, 
				    venta_credito, 
				    venta_contado, 
				    pago_proveed, 
				    cobranzas, 
				    id_tipcaja, 
				    id_moneda, 
				    caja_banco, 
				    nro_cuenta, 
				    idusuario_a, 
				    idusuario_r,
				    id_sucursal
				)
			VALUES (
				    _id_caja, 
				    _nombre, 
				    _id_estado, 
				    now(),
				    now(),
				    _venta_credito, 
				    _venta_contado, 
				    _pago_proveed, 
				    _cobranzas, 
				    _id_tipcaja, 
				    _id_moneda, 
				    _caja_banco, 
				    _nro_cuenta, 
				    _idusuario, 
				    _idusuario,
				    _id_sucursal
				 );
				res:='0';
			if not found then
				res:='-1';
			end if;
		else
			res:='-2';
		end if;
	else
		res:='-3';
	end if;
  end if;
  if _op=3 then
	if exists(select *from caja.tb_caja_banco where id_caja=_id_caja) then
		
		UPDATE caja.tb_caja_banco
		   SET 
		   nombre=_nombre, 
		   id_estado=_id_estado, 
		   date_act=now(), 
		   venta_credito=_venta_credito, 
		   venta_contado=_venta_contado, 
		   pago_proveed=_pago_proveed, 
		   cobranzas=_cobranzas, 
		   id_tipcaja=_id_tipcaja, 
		   id_moneda=_id_moneda, 
		   caja_banco=_caja_banco, 
		   nro_cuenta=_nro_cuenta ,
		   idusuario_a=_idusuario,
		   id_sucursal=_id_sucursal
		 WHERE id_caja=_id_caja;
		 res:='0';
		 if not found then
			res:='4';
		 end if;
	else
		res:='5';
	end if;
  end if;
  return res;
end;$$
language plpgsql;

---FUNCION PARA GRABAR TB_FACTURACION: DATE  CREATE 28-01-2013 11:7 AM POR JOSE GUEVARA YLATOMA

select *from RET_ARRAY();

CREATE OR REPLACE FUNCTION RET_ARRAY()
RETURNS TEXT[] AS  $$
DECLARE
 RES TEXT[];
 BEGIN
	res :=array[1,2,3,4,8];
	return res;
 END;$$
 LANGUAGE 'plpgsql';

 

select *from VENTAS.ISP_GRABAR_FACTURACION(1,1,'0000001','28/01/2012','0001',250,20,200,0,'N','N','S',NULL,1,1,'C-1',1,1,1,'C-1',1,1,'01','19',0,0,NULL,NULL,NULL,NULL)

 EXPLAIN ANALYZE SELECT 1 FROM PLANILLAS.TB_PERSONA
  EXPLAIN ANALYZE SELECT * FROM PLANILLAS.TB_PERSONA;
 
CREATE OR REPLACE FUNCTION VENTAS.ISP_GRABAR_FACTURACION(
	OP INTEGER, 
	_ID_DOCUMENTO         INTEGER   ,
	_NUMDOC_FACTURACION   VARCHAR(20)   ,
	_FECHA_FACTURACION    DATE   ,
	_SERIE_FACTURACION    CHAR(4)   ,
	_IMP_VENTA            NUMERIC(14,6)  ,
	_IMP_IGV              NUMERIC(14,6)  ,
	_IMP_TOTAL            NUMERIC(14,6)  ,
	_IMP_DSCTO            NUMERIC(14,6)  ,
	_IMPRESO              CHAR(1)  ,
	_ANULADO              CHAR(1)  ,
	_GENERA_MOVIMIENTO    CHAR(1) ,
	_IDUSUARIO             CHAR(4)  ,
	_ID_FORMAPAGO         INTEGER   ,
	_ID_MONEDA            INTEGER   ,
	_ID_CLIENTE           VARCHAR(12)   ,
	_ID_DIR_CLIENTE       INTEGER   ,
	_ID_SUCURSAL          INTEGER   ,
	_ID_ESTADO            INTEGER  ,
	_ID_VENDEDOR          VARCHAR(12)   ,
	_ID_IGV               INTEGER   ,
	_ID_TIPOCAMBIO        INTEGER  ,
	_ID_OPERACION         CHAR(2)   ,
	_ID_TRANZACCION       CHAR(2)   ,
	_ID_SUCURSAL_REF      INTEGER  ,
	_ID_DOCUMENTO_REF     INTEGER  ,
	_SERE_FACTURACION_REF CHAR(4)  ,
	_NUMDOC_FACTURA_REF   VARCHAR(20)  ,
	_ID_CLIENTE_REF       varchar(12)  ,
	_ID_DIR_CLIENTE_REF   INTEGER  ,
	_FECHA_FACTURA_REF    DATE  ,
	_ID_CONDICION_VENTA INTEGER
)
RETURNS text[] AS $$
DECLARE 
	RES text[];
BEGIN
RES:=array['F-0'];
IF OP=1 THEN
	IF NOT EXISTS (SELECT 1 FROM VENTAS.TB_FACTURACION 
			WHERE NUMDOC_FACTURACION=_NUMDOC_FACTURACION AND 
			FECHA_FACTURACION=_FECHA_FACTURACION AND 
			SERIE_FACTURACION=_SERIE_FACTURACION AND 
			ID_SUCURSAL=_ID_SUCURSAL AND 
			ID_DIR_CLIENTE=_ID_DIR_CLIENTE AND 
			ID_CLIENTE=_ID_CLIENTE AND 
			ID_DOCUMENTO=_ID_DOCUMENTO ) THEN
		IF EXISTS(SELECT 1 FROM PLANILLAS.tb_direccionpersona WHERE ID_PERSONA=_ID_CLIENTE AND idir_personal=_ID_DIR_CLIENTE LIMIT 5) THEN
			IF EXISTS(SELECT 1 FROM PLANILLAS.TB_PERSONA WHERE ID_PERSONA=_ID_VENDEDOR) THEN
				INSERT INTO VENTAS.TB_FACTURACION (
					ID_DOCUMENTO         ,
					NUMDOC_FACTURACION   ,
					FECHA_FACTURACION    ,
					SERIE_FACTURACION    ,
					IMP_VENTA            ,
					IMP_IGV              ,
					IMP_TOTAL            ,
					IMP_DSCTO            ,
					IMPRESO              ,
					ANULADO              ,
					DATE_ACT             ,
					GENERA_MOVIMIENTO    , 
					IDUSUARIO_R          ,
					ID_FORMAPAGO         ,
					ID_MONEDA            ,
					ID_CLIENTE           ,
					ID_DIR_CLIENTE       ,
					ID_SUCURSAL          ,
					ID_ESTADO            ,
					ID_VENDEDOR          ,
					ID_IGV               ,
					ID_TIPOCAMBIO        ,
					ID_OPERACION         ,
					ID_TRANZACCION   ,
					ID_CONDICION_VENTA
					 /*   ,
					ID_SUCURSAL_REF      ,
					ID_DOCUMENTO_REF     ,
					SERE_FACTURACION_REF ,
					NUMDOC_FACTURA_REF   ,
					ID_TRANZACCION_REF   ,
					FECHA_FACTURA_REF   */ 
				)VALUES
				(
					_ID_DOCUMENTO         ,
					_NUMDOC_FACTURACION   ,
					_FECHA_FACTURACION    ,
					_SERIE_FACTURACION    ,
					_IMP_VENTA            ,
					_IMP_IGV              ,
					_IMP_TOTAL            ,
					_IMP_DSCTO            ,
					_IMPRESO              ,
					_ANULADO              ,
					NOW()                 ,
					_GENERA_MOVIMIENTO    ,
					_IDUSUARIO          ,
					_ID_FORMAPAGO         ,
					_ID_MONEDA            ,
					_ID_CLIENTE           ,
					_ID_DIR_CLIENTE       ,
					_ID_SUCURSAL          ,
					_ID_ESTADO            ,
					_ID_VENDEDOR          ,
					_ID_IGV               ,
					_ID_TIPOCAMBIO        ,
					_ID_OPERACION         ,
					_ID_TRANZACCION   ,
					_ID_CONDICION_VENTA
					 /*   ,
					_ID_SUCURSAL_REF      ,
					_ID_DOCUMENTO_REF     ,
					_SERE_FACTURACION_REF ,
					_NUMDOC_FACTURA_REF   ,
					_ID_TRANZACCION_REF   ,
					_FECHA_FACTURA_REF */
				) 
				RETURNING ARRAY['0',
						TB_FACTURACION.id_documento::text, 
						TB_FACTURACION.serie_facturacion::text, 
						TB_FACTURACION.numdoc_facturacion::text, 
						TB_FACTURACION.fecha_facturacion::text, 
						TB_FACTURACION.ID_DIR_CLIENTE::text, 
						TB_FACTURACION.ID_CLIENTE::text,
						TB_FACTURACION.id_sucursal::text
					] INTO RES;
					IF NOT FOUND THEN
						RES:=ARRAY['F-1'];
					END IF;
			ELSE
				RES:=ARRAY['F-2'];
			END IF;
		ELSE
			RES:=ARRAY['F-3'];
		END IF;
	ELSE
		RES:=ARRAY['F-4'];
	END IF;	
END IF;
RETURN RES;
END;$$
LANGUAGE plpgsql;	


---FUNCION PARA GRABAR DETALLE DE VENTA: UTILIZADO EN EL FORM FACURACION
--FECHA: 29-01-2013 HORA 01:56  PM
--AUTOR :JOSE GUEVARA YLATOMA

CREATE OR REPLACE FUNCTION VENTAS.ISP_GRBAR_DET_FACTURACION(
	OP		      INTEGER,
	_ITEM                 INTEGER   ,
	_IMP_PRECIO           NUMERIC(14,6)  ,
	_CANTIDAD             NUMERIC(14,6)  ,
	_IMP_BRUTO            NUMERIC(14,6)  ,
	_PORCENT_DSCTO        NUMERIC(14,6)  ,
	_VALOR_VENTA          NUMERIC(14,6)  ,
	_VALOR_IGV            NUMERIC(14,6)  ,
	_IMP_TOTAL	     NUMERIC(14,6),
	_PUNTOS               INTEGER  ,
	_ID_ALMACEN           INTEGER   ,
	_ID_PRECIOS           INTEGER   ,
	_ID_UNIDAD            INTEGER   ,
	_ID_PRODUCTO          VARCHAR(19)   ,
	_ID_LISTA             INTEGER ,
	_LISTA                INTEGER  ,
	_SALDO_INICIAL        INTEGER  ,
	_GENARA_IGV           CHAR(1)  ,
	_ID_LOTE              VARCHAR(10)  ,
	_ID_ESTADO            INTEGER  ,	
	_ID_DOCUMENTO         INTEGER   ,
	_NUMDOC_FACTURACION   VARCHAR(20) ,
	_FECHA_FACTURACION    DATE   ,
	_SERIE_FACTURACION    CHAR(4)   ,
	_ID_TRANZACCION       CHAR(2)   ,
	_IDUSUARIO            CHAR(4)  ,
	_ID_SUCURSAL          INTEGER   ,
	_ID_DIR_CLIENTE	      INTEGER,
	_ID_CLIENTE           VARCHAR(12)
	

)
RETURNS TEXT[] AS  $$
DECLARE 
	RES TEXT[];
BEGIN
RES:=ARRAY['DF-0'];
IF OP=1 THEN
	IF EXISTS(SELECT 1 FROM VENTAS.TB_FACTURACION WHERE ID_DOCUMENTO=_ID_DOCUMENTO AND
		 NUMDOC_FACTURACION=_NUMDOC_FACTURACION AND FECHA_FACTURACION=_FECHA_FACTURACION AND 
		SERIE_FACTURACION=_SERIE_FACTURACION AND ID_CLIENTE=_ID_CLIENTE AND ID_DIR_CLIENTE=_ID_DIR_CLIENTE  AND  ID_SUCURSAL=_ID_SUCURSAL) THEN
		IF EXISTS (SELECT *FROM ALMACEN.tb_precio WHERE ID_PRECIOS=_ID_PRECIOS AND 
			ID_UNIDAD=_ID_UNIDAD AND  ID_PRODUCTO=_ID_PRODUCTO AND  ID_LISTA=_ID_LISTA)	 THEN
			INSERT INTO VENTAS.TB_DET_FACTURACION(
				ITEM,
				IMP_PRECIO,
				CANTIDAD  ,
				IMP_BRUTO ,
				PORCENT_DSCTO,
				VALOR_VENTA  ,
				VALOR_IGV    ,
				IMP_TOTAL,
				PUNTOS   ,
				ID_ALMACEN,
				ID_PRECIOS,
				ID_UNIDAD ,
				ID_PRODUCTO,
				ID_LISTA   ,
				LISTA      ,
				SALDO_INICIAL,
				GENARA_IGV   ,
				ID_LOTE      ,
				ID_ESTADO    ,	
				ID_DOCUMENTO ,
				NUMDOC_FACTURACION,
				FECHA_FACTURACION ,
				SERIE_FACTURACION ,
				--ID_TRANZACCION    ,
				IDUSUARIO_R       ,
				ID_SUCURSAL,
				ID_DIR_CLIENTE,
				ID_CLIENTE
			)
			VALUES(
				_ITEM,
				_IMP_PRECIO,
				_CANTIDAD  ,
				_IMP_BRUTO ,
				_PORCENT_DSCTO,
				_VALOR_VENTA  ,
				_VALOR_IGV    ,
				_IMP_TOTAL,
				_PUNTOS   ,
				_ID_ALMACEN,
				_ID_PRECIOS,
				_ID_UNIDAD ,
				_ID_PRODUCTO,
				_ID_LISTA   ,
				_LISTA      ,
				_SALDO_INICIAL,
				_GENARA_IGV   ,
				null,--_ID_LOTE      ,
				_ID_ESTADO    ,	
				_ID_DOCUMENTO ,
				_NUMDOC_FACTURACION,
				_FECHA_FACTURACION ,
				_SERIE_FACTURACION ,
				--_ID_TRANZACCION    ,
				_IDUSUARIO       ,
				_ID_SUCURSAL,
				_ID_DIR_CLIENTE,
				_ID_CLIENTE

			) RETURNING ARRAY['0',
						TB_DET_FACTURACION.ITEM::text,
						TB_DET_FACTURACION.ID_DOCUMENTO::text,
						TB_DET_FACTURACION.NUMDOC_FACTURACION::text,
						TB_DET_FACTURACION.FECHA_FACTURACION::text,
						TB_DET_FACTURACION.SERIE_FACTURACION::text,
						TB_DET_FACTURACION.ID_PRECIOS::text,
						TB_DET_FACTURACION.ID_UNIDAD::text,
						TB_DET_FACTURACION.ID_PRODUCTO::text,
						TB_DET_FACTURACION.ID_LISTA::text,
						TB_DET_FACTURACION.ID_SUCURSAL::text,
						TB_DET_FACTURACION.ID_DIR_CLIENTE::text,
						TB_DET_FACTURACION.ID_CLIENTE::text
					] INTO RES;
			IF NOT FOUND THEN
				RES:=ARRAY['DF-1'];
			END IF;
			
		ELSE
			RES:=ARRAY['DF-2'];
		END IF;
	ELSE
		RES:=ARRAY['DF-3'];
	END IF;
END IF;
RETURN RES;
END;$$	
LANGUAGE 'plpgsql';



---FUNCION PARA GRABAR MOVIMIENTOS DE CAJA DESDE VENTAS CUANDO SE EFECTUA UNA VENTA AL CONTADO
--O UNA VENTA LA CREDITO O AMORTIZAR UNA CUOTA DE UN VENTA AL CREDITO
--AUTOR: JOSE GUEVARA YLATOMA FECHA : 29:38 PM



CREATE OR REPLACE  FUNCTION CAJA.ISP_GRABAR_MOVFACTURACION(
	_ID_MOVIMIENTO        INTEGER ,
	_SERIE                CHAR(4)  ,
	_NRO_COMPROBANTE      CHAR(7)  ,
	_ID_CAJA_DESTINO      INTEGER  ,
	_DOC_REFERENCIA       VARCHAR(12)  ,
	_IMPORTE_MORA         NUMERIC(14,6) ,
	_IMP_MOVIMIENTO       NUMERIC(14,6) ,
	_GLOSA                TEXT  ,
	_DESACARGO            CHAR(1) ,
	_IMP_RECIBIDO         NUMERIC(14,6)  ,
	_IMP_VUELTO           NUMERIC(14,6)  ,
	_ID_DOCUMENTO_FAC     INTEGER  ,
	_NUMDOC_FACTURACION   VARCHAR(20) ,
	_FECHA_FACTURACION    DATE  ,
	_ID_SUCURSAL_FAC      INTEGER  ,
	_SERIE_FACTURACION    CHAR(4)  ,
	_ID_CLIENTE	      VARCHAR(12)  ,
	_ID_DIR_CLIENTE	      INTEGER  ,
	_IDUSUARIO            CHAR(4)  ,
	_ID_SUCURSAL_MOV      INTEGER   ,
	_ID_COBRADOR          VARCHAR(12) ,
	_ID_TRANZACCION_MOV   CHAR(2)  ,
	_FECHA_MOV            TIMESTAMP  ,
	_ID_ESTADO            INTEGER  ,
	_NRO_OPERACION        VARCHAR(20)  ,
	_id_documento_mov     INTEGER
)
RETURNS TEXT[] AS $$
DECLARE
	RES TEXT[];
BEGIN
RES:=ARRAY['MF-0'];
IF  EXISTS(SELECT 1 FROM VENTAS.TB_FACTURACION WHERE  NUMDOC_FACTURACION=_NUMDOC_FACTURACION AND 
			FECHA_FACTURACION=_FECHA_FACTURACION AND 
			SERIE_FACTURACION=_SERIE_FACTURACION AND 
			ID_SUCURSAL=_ID_SUCURSAL_FAC AND 
			ID_DIR_CLIENTE=_ID_DIR_CLIENTE AND 
			ID_CLIENTE=_ID_CLIENTE AND 
			ID_DOCUMENTO=_ID_DOCUMENTO_FAC) THEN
	INSERT INTO caja.tb_movimiento (
			ID_MOVIMIENTO,
			SERIE,
			NRO_COMPROBANTE,
			ID_CAJA_DESTINO,
			DOC_REFERENCIA ,
			IMPORTE_MORA,
			IMP_MOVIMIENTO,
			GLOSA        ,
			DESACARGO    ,
			IMP_RECIBIDO ,
			IMP_VUELTO   ,
			ID_DOCUMENTO_FAC,
			NUMDOC_FACTURACION,
			FECHA_FACTURACION ,
			ID_SUCURSAL_FAC   ,
			SERIE_FACTURACION ,
			ID_CLIENTE,
			ID_DIR_CLIENTE,
			DATE_ACT          ,
			IDUSUARIO_A       ,
			IDUSUARIO_R       ,
			ID_SUCURSAL_MOV   ,
			ID_COBRADOR       ,
			ID_TRANZACCION_MOV,
			FECHA_MOV         ,
			ID_ESTADO         ,
			NRO_OPERACION     ,
			id_documento_mov ,
			FECHA
		)
		VALUES(
			_ID_MOVIMIENTO,
			_SERIE,
			_NRO_COMPROBANTE,
			_ID_CAJA_DESTINO,
			_DOC_REFERENCIA ,
			_IMPORTE_MORA,
			_IMP_MOVIMIENTO,
			_GLOSA        ,
			_DESACARGO    ,
			_IMP_RECIBIDO ,
			_IMP_VUELTO   ,
			_ID_DOCUMENTO_FAC,
			_NUMDOC_FACTURACION,
			_FECHA_FACTURACION ,
			_ID_SUCURSAL_FAC   ,
			_SERIE_FACTURACION ,
			_ID_CLIENTE,
			_ID_DIR_CLIENTE,
			NOW()          ,
			_IDUSUARIO       ,
			_IDUSUARIO       ,
			_ID_SUCURSAL_MOV   ,
			_ID_COBRADOR       ,
			_ID_TRANZACCION_MOV,
			_FECHA_MOV         ,
			_ID_ESTADO         ,
			_NRO_OPERACION ,
			_id_documento_mov,
			NOW()
		) RETURNING ARRAY['0',
					tb_movimiento.ID_MOVIMIENTO::TEXT,
					tb_movimiento.ID_SUCURSAL_MOV::TEXT 
				]INTO RES;
		IF NOT FOUND THEN
			RES:=ARRAY['MF-1'];
		END IF;
ELSE
	RES:=ARRAY['MF-3'];
END IF;
RETURN RES;
END;$$
LANGUAGE 'plpgsql';


--FUNCION PARA REGISTAR SERIES DE CORRELATIVOS Y PLANTILLAS DE LOS COMPROVANTES DE VENTAS
--AUTOR:JOSE GUEVARA YLATOA  | FECHA : 30-10-2013 10 : 53 PM

CREATE OR REPLACE FUNCTION COMMON.ISP_GRABAR_SERIES_COMP(
	OP		     INTEGER,
	_ID_TRANZACCION       CHAR(2),
	_ID_DOCUMENTO         INTEGER   ,
	_SERIE                CHAR(4)   ,
	_NUMERO               INTEGER  ,
	_IMPRESORA            TEXT  ,
	_PLANTILLA            TEXT  ,
	_SERIE_IMPRESORA      VARCHAR(50)  ,
	_ID_SUCURSAL          INTEGER   ,
	_ID_ESTADO            INTEGER  ,
	_IDUSUARIO          CHAR(4)  ,
	_DESDE                INTEGER  ,
	_HASTA                INTEGER  ,
	_ID_TERMINAL          INTEGER  
)
RETURNS TEXT AS $$
DECLARE
	RES TEXT;
BEGIN
IF OP=1 THEN
	IF NOT EXISTS (SELECT *FROM COMMON.TB_SERIES_COMPROBANTE 
			WHERE ID_TRANZACCION=_ID_TRANZACCION AND 
			ID_DOCUMENTO=_ID_DOCUMENTO AND
			SERIE=_SERIE AND ID_SUCURSAL=_ID_SUCURSAL) THEN
		INSERT INTO COMMON.TB_SERIES_COMPROBANTE (
				ID_TRANZACCION,
				ID_DOCUMENTO ,
				SERIE,
				NUMERO,
				IMPRESORA,
				PLANTILLA,
				SERIE_IMPRESORA,
				ID_SUCURSAL    ,
				ID_ESTADO      ,
				DATE_ACT       ,
				FEC_REGISTRO   ,
				IDUSUARIO_A    ,
				IDUSUARIO_R    ,
				DESDE          ,
				HASTA          ,
				ID_TERMINAL    
			
			)
			VALUES(
				_ID_TRANZACCION,
				_ID_DOCUMENTO ,
				_SERIE,
				_NUMERO,
				_IMPRESORA,
				_PLANTILLA,
				_SERIE_IMPRESORA,
				_ID_SUCURSAL    ,
				_ID_ESTADO      ,
				NOW()       ,
				now()   ,
				_IDUSUARIO    ,
				_IDUSUARIO    ,
				_DESDE          ,
				_HASTA          ,
				_ID_TERMINAL 
			);
		RES:='0';
		IF NOT FOUND THEN
			RES='-1';
		END IF;
	ELSE
		RES:='-2';
	END IF;
END IF;
IF OP=3 THEN
	IF EXISTS(SELECT *FROM COMMON.TB_SERIES_COMPROBANTE 
			WHERE ID_TRANZACCION=_ID_TRANZACCION AND 
			ID_DOCUMENTO=_ID_DOCUMENTO AND
			SERIE=_SERIE AND ID_SUCURSAL=_ID_SUCURSAL) THEN
		UPDATE COMMON.TB_SERIES_COMPROBANTE SET
				NUMERO=_NUMERO,
				IMPRESORA=_IMPRESORA,
				PLANTILLA=_PLANTILLA,
				SERIE_IMPRESORA=_SERIE_IMPRESORA,
				ID_ESTADO=_ID_ESTADO   ,
				DATE_ACT=NOW()       ,
				IDUSUARIO_A=_IDUSUARIO    ,
				DESDE=_DESDE,
				HASTA=_HASTA          ,
				ID_TERMINAL=_ID_TERMINAL    
			WHERE ID_TRANZACCION=_ID_TRANZACCION AND 
			ID_DOCUMENTO=_ID_DOCUMENTO AND
			SERIE=_SERIE AND ID_SUCURSAL=_ID_SUCURSAL;

		RES:='0';
		IF NOT FOUND THEN
			RES='-3';
		END IF;
	ELSE
		RES:='-4';
	END IF;
END IF;
return res;
END;$$
LANGUAGE 'plpgsql';





  
CREATE OR REPLACE FUNCTION COMMON.ISP_GET_CORRELATIVO(
	_Id_Tranzaccion character, 
	_Id_Documento integer, 
	_serie character, 
	_id_sucursal integer
)
  RETURNS text AS
$BODY$

DECLARE
	--_SERIE TEXT;
	CORRELATIVO TEXT;
	INCREMETO INTEGER;
BEGIN
CORRELATIVO:='00';
	IF exists(select *from COMMON.tb_series_comprobante where id_tranzaccion=_Id_Tranzaccion and 
								id_documento=_Id_Documento and 
								serie=_serie ) then
		select  max(numero) into CORRELATIVO from COMMON.tb_series_comprobante where  
								id_tranzaccion=_Id_Tranzaccion and 
								id_documento=_Id_Documento and 
								serie=_serie  ;
		 IF CORRELATIVO IS NULL THEN 
			CORRELATIVO='1';
		ELSE
			INCREMETO=CORRELATIVO::INTEGER+1;
			CORRELATIVO= INCREMETO::TEXT ;
		END IF;
	end if;
RETURN CORRELATIVO  ;
END;$BODY$
  LANGUAGE plpgsql ;




---FUNCION QUE PERMITE GRABAR LA CABCERA DE CREDITOS QUE PUEDE SER UTILIZADA EN COMPRAS SI ES UNA VENTA AL CREDITO Y ENVENTAS SI ES UNA VENTA AL CREDITO
---AUTOR:JOSE GUEVARA YLATOMA : FECHA : 05-02-2013
ALTER TABLE CREDITOS.TB_CREDITO ADD COLUMN ID_ESTADO INTEGER;

CREATE OR REPLACE FUNCTION CREDITOS.ISP_GRABAR_CAB_CREDITO(
	 OP		     INTEGER,
	_ID_CREDITO           VARCHAR(8),
	_ID_PRODCREDITO       INTEGER ,
	_IMP_RECARGO          NUMERIC(14,6),
	_IMP_AMORTIZACION     NUMERIC(14,6),
	_IMP_CUOTA            NUMERIC(14,6),
	_IMP_CUOTACAPITAL     NUMERIC(14,6),
	_IMP_INTERES          NUMERIC(14,6),
	_NRO_CUOTAS           NUMERIC(14,6),
	_INTERVALO_CUOTA      INTEGER ,
	_MESE_PAGO_INTERES    INTEGER ,
	_ID_ESTADO            INTEGER ,
	_FACTURADO            CHAR(1) ,
	_ID_ANTICIPO          VARCHAR(10) ,
	_ID_SUCURSAL_CREDITO  INTEGER,
	_IMP_CREDITO          NUMERIC(20,6),
	_IDUSUARIO            CHAR(4) 
)
RETURNS TEXT[] AS  $$
DECLARE
	RES TEXT[];
BEGIN
IF OP=1 THEN
	IF  EXISTS (SELECT *FROM HOTEL.TB_HOTEL WHERE ID_HOTEL=_ID_SUCURSAL_CREDITO) THEN
		INSERT INTO CREDITOS.TB_CREDITO(
				ID_CREDITO         ,
				ID_PRODCREDITO     ,
				FEC_EMISION        ,
				IMP_RECARGO        ,
				IMP_AMORTIZACION   ,
				IMP_CUOTA          ,
				IMP_CUOTACAPITAL   ,
				IMP_INTERES        ,
				NRO_CUOTAS         ,
				INTERVALO_CUOTA    ,
				MESE_PAGO_INTERES  ,
				ID_ESTADO             ,
				FACTURADO          ,
				ID_ANTICIPO        ,
				ID_SUCURSAL_CREDITO,
				IMP_CREDITO ,
				DATE_ACT    ,
				IDUSUARIO_A,
				IDUSUARIO_R
				)
			VALUES(
				_ID_CREDITO         ,
				_ID_PRODCREDITO     ,
				now()        ,
				_IMP_RECARGO        ,
				_IMP_AMORTIZACION   ,
				_IMP_CUOTA          ,
				_IMP_CUOTACAPITAL   ,
				_IMP_INTERES        ,
				_NRO_CUOTAS         ,
				_INTERVALO_CUOTA    ,
				_MESE_PAGO_INTERES  ,
				_ID_ESTADO             ,
				_FACTURADO          ,
				_ID_ANTICIPO        ,
				_ID_SUCURSAL_CREDITO,
				_IMP_CREDITO ,
				now()    ,
				_IDUSUARIO,
				_IDUSUARIO
			)RETURNING ARRAY[
				'0',
				TB_CREDITO.ID_CREDITO::text,
				TB_CREDITO.ID_SUCURSAL_CREDITO::text
			] INTO RES;
			IF NOT FOUND THEN
				RES:=ARRAY['C-1'];
			END IF;
	ELSE
		RES:=ARRAY['C-2'];
	END IF;
END IF;
RETURN RES;
END;$$
LANGUAGE 'plpgsql';

SELECT *FROM CREDITOS.TB_CREDITO
---FUNCION QUE PERMITE REGISTAR LAS CUOTAS DE CREDITOS YA SEA DEESDE COMPRAS O DESDE VENTAS

----AUTOR:JOSE GUEVARA YLATOMA

CREATE OR REPLACE FUNCTION CREDITOS.ISP_GRABAR_CUOTA(
	OP INTEGER,
	_ID_CUOTA             VARCHAR(7)  ,
	_ID_CREDITO           VARCHAR(8)  ,
	_NRO_LETRA            VARCHAR(12) ,
	_FEC_VENCIMIENTO      TIMESTAMP ,
	_IMP_CAPITAL          NUMERIC(14,6)  ,
	_IMP_INTERES          NUMERIC(14,6)  ,
	_IMP_CUOTA            NUMERIC(14,6)  ,
	_IMP_ADICIONAL        NUMERIC(14,6)  ,
	_INTERVALO_DIAS       INTEGER  ,
	_DIAS_GRACIA          INTEGER  ,
	_IMP_MORA             NUMERIC(14,6)  ,
	_FEC_PAGO             TIMESTAMP  ,
	_GENERA_MORA          CHAR(1)  ,
	_FEC_REFINANCIAMIENTO TIMESTAMP  ,
	_FEC_EMISION          TIMESTAMP  ,
	_ID_SUCURSAL_CREDITO  INTEGER   ,
	_IDUSUARIO          CHAR(4)  ,
	_ID_ESTADO            INTEGER  
)
RETURNS TEXT[] AS  $$
DECLARE
	RES TEXT[];
BEGIN
IF OP=1 THEN
	--IF EXISTS(SELECT *FROM CREDITOS.TB_CREDITO WHERE ID_CREDITO=_ID_CREDITO  AND ID_SUCURSAL_CREDITO=_ID_SUCURSAL_CREDITO) THEN
		INSERT INTO CREDITOS.TB_CUOTA (
			ID_CUOTA  ,
			ID_CREDITO,
			NRO_LETRA ,
			FEC_VENCIMIENTO,
			IMP_CAPITAL    ,
			IMP_INTERES    ,
			IMP_CUOTA      ,
			IMP_ADICIONAL  ,
			INTERVALO_DIAS ,
			DIAS_GRACIA    ,
			IMP_MORA       ,
			FEC_PAGO       ,
			DATE_ACT       ,
			GENERA_MORA    ,
			--FEC_REFINANCIAMIENTO,
			FEC_EMISION         ,
			ID_SUCURSAL_CREDITO ,
			IDUSUARIO_R         ,
			IDUSUARIO_A         ,
			ID_ESTADO 
		)
		VALUES(
			_ID_CUOTA  ,
			_ID_CREDITO,
			_NRO_LETRA ,
			_FEC_VENCIMIENTO,
			_IMP_CAPITAL    ,
			_IMP_INTERES    ,
			_IMP_CUOTA      ,
			_IMP_ADICIONAL  ,
			_INTERVALO_DIAS ,
			_DIAS_GRACIA    ,
			_IMP_MORA       ,
			_FEC_PAGO       ,
			now()       ,
			_GENERA_MORA    ,
			--_FEC_REFINANCIAMIENTO,
			now()         ,
			_ID_SUCURSAL_CREDITO ,
			_IDUSUARIO         ,
			_IDUSUARIO         ,
			_ID_ESTADO 
		)RETURNING ARRAY['0',
				TB_CUOTA.ID_CUOTA::TEXT,
				TB_CUOTA.ID_CREDITO::TEXT,
				TB_CUOTA.ID_SUCURSAL_CREDITO::TEXT
				] INTO RES;
		IF NOT FOUND THEN
			RES:=ARRAY['CC-1'];
		END IF;
	/*-ELSE
		RES:=ARRAY['CC-2'];
	END IF;*/
END IF;
RETURN RES;
END;$$
LANGUAGE 'plpgsql';


---------	FUNCION QUE PERMITE VINCULAR LA FACTURACION CON LOS CREDITOS
----FOMULARIO FACTURACION
---AUTOR :JOSE GUEVARA YLATOMA

CREATE OR REPLACE   FUNCTION CREDITOS.ISP_GRBARFACT_CREDITO(
	OP	              INTEGER,
	_ID_CREDITO           VARCHAR(8) ,
	_ID_ESTADO            INTEGER ,
	_NUMDOC_FACTURACION   VARCHAR(20) ,
	_FECHA_FACTURACION    DATE ,
	_SERIE_FACTURACION    CHAR(4) ,
	_IDUSUARIO          CHAR(4) ,
	_ID_SUCURSAL          INTEGER ,
	_ID_DIR_CLIENTE       INTEGER ,
	_ID_DOCUMENTO         INTEGER ,
	_ID_CLIENTE           VARCHAR(12) ,
	_ID_SUCURSAL_CREDITO  INTEGER 
)
RETURNS TEXT[] AS $$
DECLARE
	RES TEXT[];
	ANTICIPO TEXT;
BEGIN 
 if OP=1 THEN
	IF EXISTS (SELECT *FROM VENTAS.TB_FACTURACION WHERE NUMDOC_FACTURACION =_NUMDOC_FACTURACION AND
		FECHA_FACTURACION=_FECHA_FACTURACION AND
		SERIE_FACTURACION=_SERIE_FACTURACION AND
		ID_SUCURSAL=_ID_SUCURSAL AND 
		ID_DIR_CLIENTE=_ID_DIR_CLIENTE AND
		ID_CLIENTE=_ID_CLIENTE AND
		ID_DOCUMENTO=_ID_DOCUMENTO) THEN
		IF EXISTS (SELECT *FROM CREDITOS.TB_CREDITO WHERE ID_CREDITO=_ID_CREDITO AND
			ID_SUCURSAL_CREDITO=_ID_SUCURSAL_CREDITO)THEN
			ANTICIPO:=CREDITOS.ISP_FAC_ANTICIPO(_ID_CREDITO,_ID_SUCURSAL_CREDITO);
			INSERT INTO CREDITOS.TB_FAC_CREDITO
				(
					ID_CREDITO,
					FEC_REGISTRO,
					ID_ESTADO   ,
					NUMDOC_FACTURACION ,
					FECHA_FACTURACION,
					SERIE_FACTURACION,
					DATE_ACT         ,
					IDUSUARIO_A      ,
					IDUSUARIO_R      ,
					ID_SUCURSAL      ,
					ID_DIR_CLIENTE   ,
					ID_DOCUMENTO     ,
					ID_CLIENTE       ,
					ID_SUCURSAL_CREDITO
				)VALUES(
					_ID_CREDITO,
					NOW(),
					_ID_ESTADO   ,
					_NUMDOC_FACTURACION ,
					_FECHA_FACTURACION,
					_SERIE_FACTURACION,
					NOW()         ,
					_IDUSUARIO     ,
					_IDUSUARIO      ,
					_ID_SUCURSAL      ,
					_ID_DIR_CLIENTE   ,
					_ID_DOCUMENTO     ,
					_ID_CLIENTE       ,
					_ID_SUCURSAL_CREDITO
				) RETURNING ARRAY['0'] INTO RES;
				
			IF NOT FOUND THEN
				RES:=ARRAY['FC-1'];
			END IF;
		ELSE
			RES:=ARRAY['FC-2'];
		END IF;
	ELSE
		RES:=ARRAY['FC-3'];
	END IF;
 END IF;
 RETURN RES;
END;$$
LANGUAGE 'plpgsql';


				UPDATE 
				SELECT *FROM CREDITOS.TB_ANTICIPO  WHERE ID_ANTICIPO='9'


SELECT *FROM CREDITOS.TB_CREDITO

SELECT CREDITOS.ISP_FAC_ANTICIPO('21',1);

CREATE OR REPLACE FUNCTION CREDITOS.ISP_FAC_ANTICIPO(
	_ID_CREDITO           VARCHAR(8) ,
	_ID_SUCURSAL          INTEGER 
)
RETURNS TEXT AS $$
DECLARE
	_ID_ANTICIPO TEXT;
	RES TEXT;
BEGIN
	SELECT ID_ANTICIPO INTO _ID_ANTICIPO FROM CREDITOS.TB_CREDITO WHERE ID_CREDITO=_ID_CREDITO AND ID_SUCURSAL_CREDITO=_ID_SUCURSAL;
	UPDATE CREDITOS.TB_ANTICIPO SET FACTURADO='S' WHERE ID_ANTICIPO=_ID_ANTICIPO;
	RES:='0';
RETURN RES;
END;$$
LANGUAGE 'plpgsql';

select *from caja.tb_movimiento

CREATE OR REPLACE  FUNCTION CAJA.ISP_GRABAR_MOVCUOTA(
	_ID_MOVIMIENTO        INTEGER ,
	_SERIE                CHAR(4)  ,
	_NRO_COMPROBANTE      CHAR(7)  ,
	_ID_CAJA_DESTINO      INTEGER  ,
	_DOC_REFERENCIA       VARCHAR(12)  ,
	_IMPORTE_MORA         NUMERIC(14,6) ,
	_IMP_MOVIMIENTO       NUMERIC(14,6) ,
	_GLOSA                TEXT  ,
	_DESACARGO            CHAR(1) ,
	_IMP_RECIBIDO         NUMERIC(14,6)  ,
	_IMP_VUELTO           NUMERIC(14,6)  ,	
	_IDUSUARIO            CHAR(4)  ,
	_ID_SUCURSAL_MOV      INTEGER   ,
	_ID_COBRADOR          VARCHAR(12) ,
	_ID_TRANZACCION_MOV   CHAR(2)  ,
	_FECHA_MOV            TIMESTAMP  ,
	_ID_ESTADO            INTEGER  ,
	_NRO_OPERACION        VARCHAR(20)  ,
	_ID_CUOTA             VARCHAR(7)  ,
	_ID_CREDITO           VARCHAR(8)  ,
	_ID_SUCURSAL_CREDITO  INTEGER,
	_ID_DOCUMENTO_MOV     INTEGER
	
)
RETURNS TEXT[] AS $$
DECLARE
	RES TEXT[];
BEGIN
RES:=ARRAY['MF-0'];
IF  EXISTS(SELECT 1 FROM CREDITOS.TB_CUOTA WHERE  
			ID_CUOTA=_ID_CUOTA AND
			ID_CREDITO=_ID_CREDITO AND
			ID_SUCURSAL_CREDITO=_ID_SUCURSAL_CREDITO) THEN
	INSERT INTO caja.tb_movimiento (
			ID_MOVIMIENTO,
			SERIE,
			NRO_COMPROBANTE,
			ID_CAJA_DESTINO,
			DOC_REFERENCIA ,
			IMPORTE_MORA,
			IMP_MOVIMIENTO,
			GLOSA        ,
			DESACARGO    ,
			IMP_RECIBIDO ,
			IMP_VUELTO   ,			
			DATE_ACT          ,
			IDUSUARIO_A       ,
			IDUSUARIO_R       ,
			ID_SUCURSAL_MOV   ,
			ID_COBRADOR       ,
			ID_TRANZACCION_MOV,
			FECHA_MOV         ,
			ID_ESTADO         ,
			NRO_OPERACION ,
			ID_CUOTA,
			ID_CREDITO,
			ID_SUCURSAL_CREDITO,
			ID_DOCUMENTO_MOV
		)
		VALUES(
			_ID_MOVIMIENTO,
			_SERIE,
			_NRO_COMPROBANTE,
			_ID_CAJA_DESTINO,
			_DOC_REFERENCIA ,
			_IMPORTE_MORA,
			_IMP_MOVIMIENTO,
			_GLOSA        ,
			_DESACARGO    ,
			_IMP_RECIBIDO ,
			_IMP_VUELTO   ,
			NOW()          ,
			_IDUSUARIO       ,
			_IDUSUARIO       ,
			_ID_SUCURSAL_MOV   ,
			_ID_COBRADOR       ,
			_ID_TRANZACCION_MOV,
			_FECHA_MOV         ,
			_ID_ESTADO         ,
			_NRO_OPERACION ,
			_ID_CUOTA,
			_ID_CREDITO,
			_ID_SUCURSAL_CREDITO,
			_ID_DOCUMENTO_MOV
		) RETURNING ARRAY['0',
					tb_movimiento.ID_MOVIMIENTO::TEXT,
					tb_movimiento.ID_SUCURSAL_MOV::TEXT 
				]INTO RES;
		IF NOT FOUND THEN
			RES:=ARRAY['MF-1'];
		END IF;
ELSE
	RES:=ARRAY['MF-3'];
END IF;
RETURN RES;
END;$$
LANGUAGE 'plpgsql';



CREATE OR REPLACE FUNCTION ALMACEN.ISP_GRBAR_INVENTARIO(
          op  integer,  
	  _id_almacen integer ,
	  _anio character(4)  ,
	  _fecha date  ,
	  _imp_total numeric(14,6),
	  _consolidado boolean,
	  _idusuario character(4),
	  _id_estado integer,
	  _serie character(4)  ,
	  _nro_inventario character(7)  ,
	  _id_documento integer ,
	  _id_tipoinv integer  ,
	  _referencia text,
	  _id_tranzaccion character(2)
)
RETURNS TEXT[] AS $$
DECLARE
	RES text[];
BEGIN
if op=1 then
	if not exists(select *from almacen.tb_inventario where id_almacen=_id_almacen and  
					id_documento=_id_documento and 
					serie=_serie and 
					nro_inventario=_nro_inventario AND fecha=_fecha) then
		INSERT INTO almacen.tb_inventario(
			    id_almacen, 
			    anio, 
			    fecha, 
			    imp_total, 
			    consolidado, 
			    idusuario_r, 
			    id_estado, 
			    serie, 
			    nro_inventario, 
			    id_documento, 
			    idusuario_a, 
			    id_tipoinv, 
			    referencia, 
			    id_tranzaccion
			    )
		    VALUES (
			    _id_almacen, 
			    _anio, 
			    _fecha, 
			    _imp_total, 
			    _consolidado, 
			    _idusuario, 
			    _id_estado, 
			    _serie, 
			    _nro_inventario, 
			    _id_documento, 
			    _idusuario, 
			    _id_tipoinv, 
			    _referencia, 
			    _id_tranzaccion
			) RETURNING ARRAY['0',
				tb_inventario.id_almacen::TEXT, 
				tb_inventario.id_documento::TEXT, 
				tb_inventario.serie::TEXT, 
				tb_inventario.nro_inventario::TEXT, 
				tb_inventario.fecha::TEXT
			] INTO RES;
		   IF NOT FOUND THEN
			RES:=ARRAY['I-1'];
		   END IF;
	ELSE
		RES:=ARRAY['I-2'];
		
	end if;
RETURN RES;
end if;
END;$$
LANGUAGE 'plpgsql';

CREATE OR REPLACE FUNCTION ALMACEN.ISP_SAVE_DET_INVENTORY(
	OP		     INTEGER,
	_ID_ALMACEN           INTEGER   ,
	_CANTIDAD             NUMERIC(14,6)  ,
	_COSTO                NUMERIC(14,6)  ,
	_TOTAL                NUMERIC(14,6)  ,
	_CONSOLIDAD           BOOLEAN  ,
	_ID_ESTADO            INTEGER  ,
	_ID_PRECIOS           INTEGER   ,
	_ID_UNIDAD            INTEGER   ,
	_ID_PRODUCTO          VARCHAR(19)   ,
	_ID_LISTA             INTEGER ,
	_IDUSUARIO            CHAR(4)  ,
	_ID_DOCUMENTO         INTEGER  ,
	_SERIE                CHAR(4)   ,
	_NRO_INVENTARIO       CHAR(7)   ,
	_FECHA                DATE   ,
	_NRO_LOTE             VARCHAR(30)  ,
	_ITEM                 INTEGER  

)
RETURNS TEXT[] AS  $$
DECLARE 
	RES TEXT[];
BEGIN
if op=1 then
	if exists (select *from ALMACEN.TB_INVENTARIO  
		where ID_ALMACEN=_ID_ALMACEN AND 
		ID_DOCUMENTO =_ID_DOCUMENTO AND 
		SERIE=_SERIE AND 
		NRO_INVENTARIO=_NRO_INVENTARIO AND 
		FECHA=_FECHA) THEN
		IF EXISTS (SELECT *FROM  ALMACEN.TB_PRECIO WHERE ID_PRECIOS=_ID_PRECIOS AND 
			ID_UNIDAD =_ID_UNIDAD AND 
			ID_PRODUCTO=_ID_PRODUCTO AND 
			ID_LISTA=_ID_LISTA) THEN
			INSERT INTO ALMACEN.TB_DET_INVENTARIO (
				ID_ALMACEN,
				CANTIDAD,
				COSTO,
				TOTAL,
				CONSOLIDAD,
				ID_ESTADO,
				ID_PRECIOS,
				ID_UNIDAD,
				ID_PRODUCTO,
				ID_LISTA,
				IDUSUARIO,
				ID_DOCUMENTO,
				SERIE,
				NRO_INVENTARIO,
				FECHA,
				NRO_LOTE,
				ITEM
			)
			VALUES(
				_ID_ALMACEN,
				_CANTIDAD,
				_COSTO,
				_TOTAL,
				_CONSOLIDAD,
				_ID_ESTADO,
				_ID_PRECIOS,
				_ID_UNIDAD,
				_ID_PRODUCTO,
				_ID_LISTA,
				_IDUSUARIO,
				_ID_DOCUMENTO,
				_SERIE,
				_NRO_INVENTARIO,
				_FECHA,
				_NRO_LOTE,
				_ITEM
			) RETURNING 
			ARRAY['0',TB_DET_INVENTARIO.ID_ALMACEN::TEXT,
				TB_DET_INVENTARIO.ID_PRECIOS::TEXT,
				TB_DET_INVENTARIO.ID_UNIDAD::TEXT,
				TB_DET_INVENTARIO.ID_PRODUCTO::TEXT,
				TB_DET_INVENTARIO.ID_LISTA::TEXT,
				TB_DET_INVENTARIO.ID_DOCUMENTO::TEXT,
				TB_DET_INVENTARIO.SERIE::TEXT,
				TB_DET_INVENTARIO.NRO_INVENTARIO::TEXT,
				TB_DET_INVENTARIO.FECHA::TEXT,
				TB_DET_INVENTARIO.ITEM::TEXT
			] into RES;
			IF NOT FOUND THEN
				RES:=ARRAY['DI-1'];
			END IF;
		ELSE
			RES:=ARRAY['DI-2'];
		END IF;
	ELSE
		RES:=ARRAY['DI-3'];
	END IF;
end if;
RETURN RES;
END;$$
LANGUAGE 'plpgsql';


CREATE OR REPLACE FUNCTION ALMACEN.ISP_GRABAR_SERIES(
	_IDSERIE              VARCHAR(30)  ,
	_ID_USUARIO           CHAR(4)  ,
	_NRO_CHASIS           VARCHAR(30)  ,
	_NRO_MOTOR            VARCHAR(30)  ,
	_ANIO_FABRICACION     CHAR(4)  ,
	_ANIO_MODELO          CHAR(4)  ,
	_ID_UNIDAD            INTEGER   ,
	_ID_PRODUCTO          VARCHAR(19) ,
	_ID_ESTADO            INTEGER  
)
RETURNS TEXT[] AS $$
DECLARE
	RES TEXT[];
 BEGIN
	IF NOT EXISTS(SELECT *FROM ALMACEN.SERIE_PRODUCTO WHERE IDSERIE=_IDSERIE) THEN
		INSERT INTO ALMACEN.SERIE_PRODUCTO (
			IDSERIE,
			FEC_REGISTRO,
			DATE_ACT,
			ID_USUARIO_A,
			ID_USUARIO_R,
			NRO_CHASIS,
			NRO_MOTOR,
			ANIO_FABRICACION,
			ANIO_MODELO,
			--VERSIONS,
			--TRACCION,
			--CAT_CLASE,
			ID_UNIDAD,
			ID_PRODUCTO,
			ID_ESTADO
			)
		VALUES(
			_IDSERIE,
			NOW(),
			NOW(),
			_ID_USUARIO,
			_ID_USUARIO,
			_NRO_CHASIS,
			_NRO_MOTOR,
			_ANIO_FABRICACION,
			_ANIO_MODELO,
			--_VERSIONS,
			--_TRACCION,
			--_CAT_CLASE,
			_ID_UNIDAD,
			_ID_PRODUCTO,
			_ID_ESTADO
		) RETURNING ARRAY['0',SERIE_PRODUCTO.IDSERIE] INTO RES;
		IF NOT FOUND THEN
			RES:=ARRAY['S-1'];
		END IF;
	ELSE
		RES:=ARRAY['S-2'];
	END IF;
RETURN RES;
END;$$
LANGUAGE 'plpgsql';



CREATE OR REPLACE FUNCTION ALMACEN.ISP_GRABAR_SERIEPROD_INV(
	_IDSERIE              VARCHAR(30)   ,
	_FECHA                DATE   ,
	_ID_ESTADO            INTEGER  ,
	_ID_ALMACEN           INTEGER   ,
	_IDUSUARIO            CHAR(4)  ,
	_ID_DOCUMENTO         INTEGER   ,
	_SERIE                CHAR(4)   ,
	_NRO_INVENTARIO       CHAR(7)   

)
RETURNS TEXT[] AS $$
DECLARE
	RES TEXT[];
BEGIN
	IF EXISTS(SELECT *FROM ALMACEN.SERIE_PRODUCTO WHERE IDSERIE=_IDSERIE) THEN
		IF EXISTS(SELECT *FROM ALMACEN.TB_INVENTARIO WHERE ID_ALMACEN=_ID_ALMACEN AND  
			ID_DOCUMENTO=_ID_DOCUMENTO AND 
			SERIE=_SERIE AND 
			NRO_INVENTARIO=_NRO_INVENTARIO AND FECHA=_FECHA)THEN
			INSERT INTO ALMACEN.SERIEPROD_INVINI(
				IDSERIE,
				FECHA,
				ID_ESTADO,
				ID_ALMACEN,
				IDUSUARIO_R,
				IDUSUARIO_A,
				ID_DOCUMENTO ,
				SERIE,
				NRO_INVENTARIO,
				DATE_ACT,
				FEC_REGISTRO 
			)
			VALUES(
				_IDSERIE,
				_FECHA,
				_ID_ESTADO,
				_ID_ALMACEN,
				_IDUSUARIO,
				_IDUSUARIO,
				_ID_DOCUMENTO ,
				_SERIE,
				_NRO_INVENTARIO,
				NOW(),
				NOW()
			) RETURNING ARRAY['0'] INTO RES;
			IF NOT FOUND THEN
				RES:=ARRAY['DSI-1'];
			END IF;
		ELSE
			RES:=ARRAY['DSI-2'];
		END IF;
	ELSE
		RES:=ARRAY['DSI-3'];
	END IF;
RETURN RES;
END;$$
LANGUAGE 'plpgsql';



CREATE OR REPLACE FUNCTION CREDITOS.ISP_GRABAR_CAB_ANTICIPO(
	OP		     INTEGER,
	_ID_ANTICIPO          VARCHAR(10)   ,
	_IDIR_PERSONAL        INTEGER   ,
	_ID_PERSONA           VARCHAR(12)   ,
	_FACTURADO            CHAR(1)  ,
	_GLOSA                TEXT  ,
	_IDUSUARIO            CHAR(4)  ,
	_TIPO_ANTICIPO        CHAR(1)  ,
	_ID_MONEDA            INTEGER
)
RETURNS TEXT[] AS  $$
DECLARE
	RES TEXT[];
	id_registro integer;
BEGIN
if op=1 then
	 IF  EXISTS (SELECT *FROM PLANILLAS.tb_direccionpersona WHERE idir_personal=_idir_personal AND  id_persona=_id_persona) THEN
			id_registro:=(select coalesce(max(ID_ANTICIPO::integer),0) from creditos.tb_anticipo);
			if(id_registro is null) then
				id_registro :=1;
			else
			id_registro:=id_registro +1;
			end if;
		INSERT INTO creditos.tb_anticipo(
				ID_ANTICIPO,
				DATE_ACT,
				FEC_REGISTRO,
				IDIR_PERSONAL,
				ID_PERSONA,
				--FACTURADO,
				GLOSA,
				IDUSUARIO_R,
				IDUSUARIO_A,
				TIPO_ANTICIPO,
				ID_MONEDA
			) VALUES(
				id_registro::text,
				NOW(),
				NOW(),
				_IDIR_PERSONAL,
				_ID_PERSONA,
				--_FACTURADO,
				_GLOSA,
				_IDUSUARIO,
				_IDUSUARIO,
				_TIPO_ANTICIPO,
				_ID_MONEDA
			) RETURNING ARRAY['0',tb_anticipo.ID_ANTICIPO::TEXT] INTO RES;
			IF NOT FOUND THEN
				RES:=ARRAY['AT-1'];
			END IF;
	ELSE
		RES:=ARRAY['AT-2'];
	 END IF;
 end if;
 IF OP=3 THEN
	IF EXISTS(SELECT *FROM CREDITOS.TB_ANTICIPO WHERE ID_ANTICIPO=_ID_ANTICIPO) THEN
		UPDATE CREEDITOS.TB_ANTICIPO SET IDIR_PERSONAL=_IDIR_PERSONAL,ID_PERSONA=_ID_PERSONA, DATE_ACT=NOW() WHERE ID_ANTICIPO=_ID_ANTICIPO;
		RES:=ARRAY['0'];
		IF NOT FOUND THEN
			RES:=ARRAY['AT-1'];
		END IF;
	ELSE	
		RES:=ARRAY['AT-2'];
	END IF;
 END IF;
 RETURN RES;
END;$$
LANGUAGE 'plpgsql';


DROP TABLE creditos.det_anticipo

ALTER TABLE creditos.det_anticipo ADD COLUMN ISPRINCIPAL INTEGER DEFAULT 0;


CREATE OR REPLACE FUNCTION CREDITOS.ISP_GRABAR_DET_ANTICIPO(
	OP INTEGER,
	_ID_ANTICIPO          VARCHAR(10)  ,
	_ITEM                 INTEGER   ,
	_CANTIDAD             NUMERIC(14,6)  ,
	_ID_ESTADO            INTEGER  ,
	_ID_PRECIOS           INTEGER ,
	_ID_UNIDAD            INTEGER   ,
	_ID_PRODUCTO          VARCHAR(19) ,
	_ID_LISTA             INTEGER ,
	_ISPRINCIPAL 	     INTEGER

)
RETURNS TEXT[] AS $$
DECLARE 
	RES TEXT[];
BEGIN
	IF EXISTS(SELECT *FROM CREDITOS.TB_ANTICIPO WHERE ID_ANTICIPO=_ID_ANTICIPO)THEN
		IF EXISTS (SELECT *FROM ALMACEN.TB_PRECIO WHERE id_precios=_id_precios AND  id_unidad=_id_unidad AND  id_producto=_id_producto AND  id_lista=_id_lista) THEN
			INSERT INTO CREDITOS.tb_det_anticipo(
				ID_ANTICIPO,
				ITEM       ,
				CANTIDAD   ,
				ID_ESTADO  ,
				ID_PRECIOS ,
				ID_UNIDAD  ,
				ID_PRODUCTO,
				ID_LISTA   ,
				DATE_ACT   ,
				FEC_REGISTRO,
				ISPRINCIPAL 
			)VALUES(
				_ID_ANTICIPO,
				_ITEM       ,
				_CANTIDAD   ,
				_ID_ESTADO  ,
				_ID_PRECIOS ,
				_ID_UNIDAD  ,
				_ID_PRODUCTO,
				_ID_LISTA   ,
				NOW()   ,
				NOW(),
				_ISPRINCIPAL
			) RETURNING ARRAY['0'] INTO RES;
			IF NOT FOUND THEN
				RES:=ARRAY['DAT-1'];
			END IF;
		ELSE
			RES:=ARRAY['DAT-2'];
		END IF;
	ELSE
		RES:=ARRAY['DAT-3'];
	END IF;
RETURN RES;
END;$$
LANGUAGE 'plpgsql';


CREATE OR REPLACE FUNCTION CAJA.ISP_ANULAR_MOV_CAJA(
	_id_sucursal INTEGER, 
	_serie CHAR(4), 
	_fecha DATE, 
	_nro_comprobante VARCHAR(12), 
	_id_tranzaccion CHAR(2), 
	_id_documento INTEGER,
	_ID_ESTADO INTEGER
)
RETURNS TEXT[] AS $$
DECLARE
	RES TEXT[];
BEGIN
	IF EXISTS (SELECT *FROM CAJA.TB_MOVIMIENTO WHERE id_sucursal_mov=_id_sucursal AND  
			serie=_serie AND  
			fecha=_fecha AND 
			nro_comprobante=_nro_comprobante AND
			id_tranzaccion_mov=_id_tranzaccion  AND  
			id_documento_mov=_id_documento) THEN
		UPDATE CAJA.TB_MOVIMIENTO SET ID_ESTADO=_ID_ESTADO WHERE id_sucursal_mov=_id_sucursal AND  
			serie=_serie AND  
			fecha=_fecha AND 
			nro_comprobante=_nro_comprobante AND
			id_tranzaccion_mov=_id_tranzaccion  AND  
			id_documento_mov=_id_documento;
			RES:=ARRAY['0'];
		IF NOT FOUND THEN
		 RES:=ARRAY['MD-1'];
		END IF;
	ELSE
		RES:=ARRAY['MD-2'];
	END IF;
RETURN RES;
END;$$
LANGUAGE 'plpgsql';


select CREDITOS.ISP_ESTADOS_CUOTA(id_sucursal_credito,id_cuota,id_credito) from creditos.tb_cuota;

CREATE OR REPLACE FUNCTION CREDITOS.ISP_ESTADOS_CUOTA(
	_id_sucursal INTEGER, 
	_id_cuota varchar(7),
	_id_credito varchar(8)
)
RETURNS TEXT AS  $$
DECLARE
	res text;
	saldo numeric(20,6);
	imp_mora numeric(20,6);
	
BEGIN
	imp_mora:=creditos.getFuncCalMora(_ID_CUOTA,_ID_CREDITO,_id_sucursal)::numeric;
	SELECT  (CC.IMP_CUOTA+CC.IMP_MORA-COALESCE((SELECT sum(M.IMP_MOVIMIENTO) FROM CAJA.TB_MOVIMIENTO M 
	WHERE CC.ID_CUOTA=M.ID_CUOTA 
	AND CC.ID_CREDITO=M.ID_CREDITO 
	AND CC.id_sucursal_credito=M.id_sucursal_credito ) ,0)) into saldo FROM CREDITOS.TB_CUOTA CC WHERE  id_cuota=_id_cuota AND  
			id_credito=_id_credito AND  id_sucursal_credito=_id_sucursal ;
	if TRUNC(saldo,2)>0 and exists(select *from creditos.tb_cuota where fec_vencimiento>now() and id_cuota=_id_cuota AND  
			id_credito=_id_credito AND  id_sucursal_credito=_id_sucursal ) then
		update creditos.tb_cuota set id_estado=9 where  id_cuota=_id_cuota AND  id_credito=_id_credito AND  id_sucursal_credito=_id_sucursal;
	else
		if (imp_mora>0 AND TRUNC(SALDO,2)>0 and exists(select *from creditos.tb_cuota where fec_vencimiento<now() and id_cuota=_id_cuota AND  
			id_credito=_id_credito AND  id_sucursal_credito=_id_sucursal )) then
			update creditos.tb_cuota set id_estado=10 where  id_cuota=_id_cuota AND  id_credito=_id_credito AND  id_sucursal_credito=_id_sucursal;
		else
			if TRUNC(saldo,2)=0 then
				update creditos.tb_cuota set id_estado=8 where  id_cuota=_id_cuota AND  id_credito=_id_credito AND  id_sucursal_credito=_id_sucursal;
			else
				
			end if;
		end if;
	end if;
	--select *from creditos.V_LISTAR_CUOTAS;
return res;
END;$$
LANGUAGE 'plpgsql';



CREATE OR REPLACE FUNCTION VENTAS.ISP_ANULAR_VENTA(
	op integer,
	_numdoc_facturacion varchar(10), 
	_fecha_facturacion date, 
	_serie_facturacion char(4), 
	_id_sucursal integer, 
	_id_dir_cliente integer, 
	_id_cliente varchar(12), 
	_id_documento integer
)
RETURNS TEXT AS  $$
DECLARE
	 monto_cencelado_cxc double precision;
	DATA_MOVIMIENTO RECORD;
BEGIN
if op=1 then
	if exists(select 1 from ventas.tb_facturacion where numdoc_facturacion=_numdoc_facturacion and 
			fecha_facturacion=_fecha_facturacion and serie_facturacion=_serie_facturacion and 
			id_sucursal=_id_sucursal and id_dir_cliente=_id_dir_cliente and 
			id_cliente=_id_cliente and id_documento=_id_documento)then
		if exists(select 1 from ventas.tb_facturacion where 
			numdoc_facturacion=_numdoc_facturacion and fecha_facturacion=_fecha_facturacion and 
			serie_facturacion=_serie_facturacion and 
			id_sucursal=_id_sucursal and id_dir_cliente=_id_dir_cliente and 
			id_cliente=_id_cliente and id_documento=_id_documento and id_estado<>7)then
			monto_cencelado_cxc=0.0;
			for DATA_MOVIMIENTO in SELECT *
							FROM
							  creditos.tb_fac_credito
							  INNER JOIN creditos.tb_credito ON (creditos.tb_fac_credito.id_credito = creditos.tb_credito.id_credito)
							  AND (creditos.tb_fac_credito.id_sucursal_credito = creditos.tb_credito.id_sucursal_credito)
							  INNER JOIN creditos.tb_cuota ON (creditos.tb_credito.id_credito = creditos.tb_cuota.id_credito)
							  AND (creditos.tb_credito.id_sucursal_credito = creditos.tb_cuota.id_sucursal_credito)
		end if;
			
	end if;
end if;
END;$$
LANGUAGE 'plpgsql';
SELECT *FROM CREDITOS.TB_CUOTA
select *from common.tb_estado